(in-package :TRAPS)
; Generated from #P"macintosh-hd:hd3:CInterface Translator:Source Interfaces:CFURL.h"
; at Sunday July 2,2006 7:22:50 pm.
; 	CFURL.h
; 	Copyright (c) 1998-2003, Apple, Inc. All rights reserved.
; 

; #if !defined(__COREFOUNDATION_CFURL__)
(defconstant $__COREFOUNDATION_CFURL__ 1)
; #define __COREFOUNDATION_CFURL__ 1

(require-interface "CoreFoundation/CFBase")

(require-interface "CoreFoundation/CFData")

(require-interface "CoreFoundation/CFString")

; #if defined(__cplusplus)
#|
extern "C" {
#endif
|#

(defconstant $kCFURLPOSIXPathStyle 0)
(defconstant $kCFURLHFSPathStyle 1)
(defconstant $kCFURLWindowsPathStyle 2)
(def-mactype :CFURLPathStyle (find-mactype ':SINT32))

(def-mactype :CFURLRef (find-mactype '(:pointer :__CFURL)))
;  CFURLs are composed of two fundamental pieces - their string, and a 
;  (possibly NULL) base URL.  A relative URL is one in which the string 
;  by itself does not fully specify the URL (for instance "myDir/image.tiff"); 
;  an absolute URL is one in which the string does fully specify the URL 
;  ("file://localhost/myDir/image.tiff").  Absolute URLs always have NULL 
;  base URLs; however, it is possible for a URL to have a NULL base, and still 
;  not be absolute.  Such a URL has only a relative string, and cannot be 
;  resolved.  Two CFURLs are considered equal if and only if their strings 
;  are equal and their bases are equal.  In other words, 
;  "file://localhost/myDir/image.tiff" is NOT equal to the URL with relative 
;  string "myDir/image.tiff" and base URL "file://localhost/".  Clients that 
;  need these less strict form of equality should convert all URLs to their 
;  absolute form via CFURLCopyAbsoluteURL(), then compare the absolute forms. 

(deftrap-inline "_CFURLGetTypeID" 
   (
   )
   :UInt32
() )
;  encoding will be used both to interpret the bytes of URLBytes, and to 
;  interpret any percent-escapes within the bytes. 

(deftrap-inline "_CFURLCreateWithBytes" 
   ((allocator (:pointer :__CFAllocator))
    (URLBytes (:pointer :UInt8))
    (length :SInt32)
    (encoding :UInt32)
    (baseURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )
;  Escapes any character that is not 7-bit ASCII with the byte-code 
;  for the given encoding.  If escapeWhitespace is true, whitespace 
;  characters (' ', '\t', '\r', '\n') will be escaped also (desirable 
;  if embedding the URL into a larger text stream like HTML) 

(deftrap-inline "_CFURLCreateData" 
   ((allocator (:pointer :__CFAllocator))
    (url (:pointer :__CFURL))
    (encoding :UInt32)
    (escapeWhitespace :Boolean)
   )
   (:pointer :__CFData)
() )
;  Any escape sequences in URLString will be interpreted via UTF-8. 

(deftrap-inline "_CFURLCreateWithString" 
   ((allocator (:pointer :__CFAllocator))
    (URLString (:pointer :__CFString))
    (baseURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )

; #if MAC_OS_X_VERSION_10_3 <= MAC_OS_X_VERSION_MAX_ALLOWED
;  Create an absolute URL directly, without requiring the extra step 
;  of calling CFURLCopyAbsoluteURL().  If useCompatibilityMode is  
;  true, the rules historically used on the web are used to resolve 
;  relativeString against baseURL - these rules are generally listed 
;  in the RFC as optional or alternate interpretations.  Otherwise, 
;  the strict rules from the RFC are used.  The major differences are 
;  that in compatibility mode, we are lenient of the scheme appearing 
;  in relative portion, leading "../" components are removed from the 
;  final URL's path, and if the relative portion contains only 
;  resource specifier pieces (query, parameters, and fragment), then 
;  the last path component of the base URL will not be deleted  

(deftrap-inline "_CFURLCreateAbsoluteURLWithBytes" 
   ((alloc (:pointer :__CFAllocator))
    (relativeURLBytes (:pointer :UInt8))
    (length :SInt32)
    (encoding :UInt32)
    (baseURL (:pointer :__CFURL))
    (useCompatibilityMode :Boolean)
   )                                            ; AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
   (:pointer :__CFURL)
() )

; #endif

;  filePath should be the URL's path expressed as a path of the type 
;  fsType.  If filePath is not absolute, the resulting URL will be 
;  considered relative to the current working directory (evaluated 
;  at creation time).  isDirectory determines whether filePath is 
;  treated as a directory path when resolving against relative path 
;  components 

(deftrap-inline "_CFURLCreateWithFileSystemPath" 
   ((allocator (:pointer :__CFAllocator))
    (filePath (:pointer :__CFString))
    (pathStyle :SInt32)
    (isDirectory :Boolean)
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateFromFileSystemRepresentation" 
   ((allocator (:pointer :__CFAllocator))
    (buffer (:pointer :UInt8))
    (bufLen :SInt32)
    (isDirectory :Boolean)
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateWithFileSystemPathRelativeToBase" 
   ((allocator (:pointer :__CFAllocator))
    (filePath (:pointer :__CFString))
    (pathStyle :SInt32)
    (isDirectory :Boolean)
    (baseURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateFromFileSystemRepresentationRelativeToBase" 
   ((allocator (:pointer :__CFAllocator))
    (buffer (:pointer :UInt8))
    (bufLen :SInt32)
    (isDirectory :Boolean)
    (baseURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )
;  Fills buffer with the file system's native representation of 
;  url's path. No more than maxBufLen bytes are written to buffer. 
;  The buffer should be at least the maximum path length for 
;  the file system in question to avoid failures for insufficiently 
;  large buffers.  If resolveAgainstBase is true, the url's relative 
;  portion is resolved against its base before the path is computed. 
;  Returns success or failure. 

(deftrap-inline "_CFURLGetFileSystemRepresentation" 
   ((url (:pointer :__CFURL))
    (resolveAgainstBase :Boolean)
    (buffer (:pointer :UInt8))
    (maxBufLen :SInt32)
   )
   :Boolean
() )
;  Creates a new URL by resolving the relative portion of relativeURL against its base. 

(deftrap-inline "_CFURLCopyAbsoluteURL" 
   ((relativeURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )
;  Returns the URL's string. 

(deftrap-inline "_CFURLGetString" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )
;  Returns the base URL if it exists 

(deftrap-inline "_CFURLGetBaseURL" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )
; 
; All URLs can be broken into two pieces - the scheme (preceding the
; first colon) and the resource specifier (following the first colon).
; Most URLs are also "standard" URLs conforming to RFC 1808 (available
; from www.w3c.org).  This category includes URLs of the file, http,
; https, and ftp schemes, to name a few.  Standard URLs start the
; resource specifier with two slashes ("//"), and can be broken into
; four distinct pieces - the scheme, the net location, the path, and
; further resource specifiers (typically an optional parameter, query,
; and/or fragment).  The net location appears immediately following
; the two slashes and goes up to the next slash; it's format is
; scheme-specific, but is usually composed of some or all of a username,
; password, host name, and port.  The path is a series of path components
; separated by slashes; if the net location is present, the path always
; begins with a slash.  Standard URLs can be relative to another URL,
; in which case at least the scheme and possibly other pieces as well
; come from the base URL (see RFC 1808 for precise details when resolving
; a relative URL against its base).  The full URL is therefore
; 
; <scheme> "://" <net location> <path, always starting with slash> <add'l resource specifiers>
; 
; If a given CFURL can be decomposed (that is, conforms to RFC 1808), you
; can ask for each of the four basic pieces (scheme, net location, path,
; and resource specifer) separately, as well as for its base URL.  The
; basic pieces are returned with any percent escape sequences still in
; place (although note that the scheme may not legally include any
; percent escapes); this is to allow the caller to distinguish between
; percent sequences that may have syntactic meaning if replaced by the
; character being escaped (for instance, a '/' in a path component).
; Since only the individual schemes know which characters are
; syntactically significant, CFURL cannot safely replace any percent
; escape sequences.  However, you can use
; CFURLCreateStringByReplacingPercentEscapes() to create a new string with
; the percent escapes removed; see below.
; 
; If a given CFURL can not be decomposed, you can ask for its scheme and its
; resource specifier; asking it for its net location or path will return NULL.
; 
; To get more refined information about the components of a decomposable
; CFURL, you may ask for more specific pieces of the URL, expressed with
; the percent escapes removed.  The available functions are CFURLCopyHostName(),
; CFURLGetPortNumber() (returns an Int32), CFURLCopyUserName(),
; CFURLCopyPassword(), CFURLCopyQuery(), CFURLCopyParameters(), and
; CFURLCopyFragment().  Because the parameters, query, and fragment of an
; URL may contain scheme-specific syntaxes, these methods take a second
; argument, giving a list of characters which should NOT be replaced if
; percent escaped.  For instance, the ftp parameter syntax gives simple
; key-value pairs as "<key>=<value>;"  Clearly if a key or value includes
; either '=' or ';', it must be escaped to avoid corrupting the meaning of
; the parameters, so the caller may request the parameter string as
; 
; CFStringRef myParams = CFURLCopyParameters(ftpURL, CFSTR("=;%"));
; 
; requesting that all percent escape sequences be replaced by the represented
; characters, except for escaped '=', '%' or ';' characters.  Pass the empty
; string (CFSTR("")) to request that all percent escapes be replaced, or NULL
; to request that none be.
; 
;  Returns true if anURL conforms to RFC 1808 

(deftrap-inline "_CFURLCanBeDecomposed" 
   ((anURL (:pointer :__CFURL))
   )
   :Boolean
() )
;  The next several methods leave any percent escape sequences intact 

(deftrap-inline "_CFURLCopyScheme" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )
;  NULL if CFURLCanBeDecomposed(anURL) is false 

(deftrap-inline "_CFURLCopyNetLocation" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )
;  NULL if CFURLCanBeDecomposed(anURL) is false; also does not resolve the URL 
;  against its base.  See also CFURLCopyAbsoluteURL().  Note that, strictly 
;  speaking, any leading '/' is not considered part of the URL's path, although 
;  its presence or absence determines whether the path is absolute. 
;  CFURLCopyPath()'s return value includes any leading slash (giving the path 
;  the normal POSIX appearance); CFURLCopyStrictPath()'s return value omits any 
;  leading slash, and uses isAbsolute to report whether the URL's path is absolute. 
;  CFURLCopyFileSystemPath() returns the URL's path as a file system path for the 
;  given path style.  All percent escape sequences are replaced.  The URL is not 
;  resolved against its base before computing the path. 

(deftrap-inline "_CFURLCopyPath" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyStrictPath" 
   ((anURL (:pointer :__CFURL))
    (isAbsolute (:pointer :Boolean))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyFileSystemPath" 
   ((anURL (:pointer :__CFURL))
    (pathStyle :SInt32)
   )
   (:pointer :__CFString)
() )
;  Returns whether anURL's path represents a directory 
;  (true returned) or a simple file (false returned) 

(deftrap-inline "_CFURLHasDirectoryPath" 
   ((anURL (:pointer :__CFURL))
   )
   :Boolean
() )
;  Any additional resource specifiers after the path.  For URLs 
;  that cannot be decomposed, this is everything except the scheme itself. 

(deftrap-inline "_CFURLCopyResourceSpecifier" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyHostName" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLGetPortNumber" 
   ((anURL (:pointer :__CFURL))
   )
   :SInt32
() )
;  Returns -1 if no port number is specified 

(deftrap-inline "_CFURLCopyUserName" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyPassword" 
   ((anURL (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )
;  These remove all percent escape sequences except those for 
;  characters in charactersToLeaveEscaped.  If charactersToLeaveEscaped 
;  is empty (""), all percent escape sequences are replaced by their 
;  corresponding characters.  If charactersToLeaveEscaped is NULL, 
;  then no escape sequences are removed at all 

(deftrap-inline "_CFURLCopyParameterString" 
   ((anURL (:pointer :__CFURL))
    (charactersToLeaveEscaped (:pointer :__CFString))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyQueryString" 
   ((anURL (:pointer :__CFURL))
    (charactersToLeaveEscaped (:pointer :__CFString))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyFragment" 
   ((anURL (:pointer :__CFURL))
    (charactersToLeaveEscaped (:pointer :__CFString))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyLastPathComponent" 
   ((url (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )

(deftrap-inline "_CFURLCopyPathExtension" 
   ((url (:pointer :__CFURL))
   )
   (:pointer :__CFString)
() )
;  These functions all treat the base URL of the supplied url as 
;  invariant.  In other words, the URL returned will always have 
;  the same base as the URL supplied as an argument. 

(deftrap-inline "_CFURLCreateCopyAppendingPathComponent" 
   ((allocator (:pointer :__CFAllocator))
    (url (:pointer :__CFURL))
    (pathComponent (:pointer :__CFString))
    (isDirectory :Boolean)
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateCopyDeletingLastPathComponent" 
   ((allocator (:pointer :__CFAllocator))
    (url (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateCopyAppendingPathExtension" 
   ((allocator (:pointer :__CFAllocator))
    (url (:pointer :__CFURL))
    (extension (:pointer :__CFString))
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLCreateCopyDeletingPathExtension" 
   ((allocator (:pointer :__CFAllocator))
    (url (:pointer :__CFURL))
   )
   (:pointer :__CFURL)
() )

; #if MAC_OS_X_VERSION_10_3 <= MAC_OS_X_VERSION_MAX_ALLOWED
;  Fills buffer with the bytes for url, returning the number of bytes 
;  filled.  If buffer is of insufficient size, returns -1 and no bytes 
;  are placed in buffer.  If buffer is NULL, the needed length is 
;  computed and returned.  The returned bytes are the original bytes 
;  from which the URL was created; if the URL was created from a 
;  string, the bytes will be the bytes of the string encoded via UTF-8  

(deftrap-inline "_CFURLGetBytes" 
   ((url (:pointer :__CFURL))
    (buffer (:pointer :UInt8))
    (bufferLength :SInt32)
   )                                            ; AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
   :SInt32
() )

(defconstant $kCFURLComponentScheme 1)
(defconstant $kCFURLComponentNetLocation 2)
(defconstant $kCFURLComponentPath 3)
(defconstant $kCFURLComponentResourceSpecifier 4)
(defconstant $kCFURLComponentUser 5)
(defconstant $kCFURLComponentPassword 6)
(defconstant $kCFURLComponentUserInfo 7)
(defconstant $kCFURLComponentHost 8)
(defconstant $kCFURLComponentPort 9)
(defconstant $kCFURLComponentParameterString 10)
(defconstant $kCFURLComponentQuery 11)
(defconstant $kCFURLComponentFragment 12)
(def-mactype :CFURLComponentType (find-mactype ':SINT32))
;  
; Gets the  range of the requested component in the bytes of url, as
; returned by CFURLGetBytes().  This range is only good for use in the
; bytes returned by CFURLGetBytes!
; 
; If non-NULL, rangeIncludingSeparators gives the range of component
; including the sequences that separate component from the previous and
; next components.  If there is no previous or next component, that end of
; rangeIncludingSeparators will match the range of the component itself.
; If url does not contain the given component type, (kCFNotFound, 0) is
; returned, and rangeIncludingSeparators is set to the location where the
; component would be inserted.  Some examples -
; 
; For the URL http://www.apple.com/hotnews/
; 
; Component           returned range      rangeIncludingSeparators
; scheme              (0, 4)              (0, 7)
; net location        (7, 13)             (4, 16)
; path                (20, 9)             (20, 9)    
; resource specifier  (kCFNotFound, 0)    (29, 0)
; user                (kCFNotFound, 0)    (7, 0)
; password            (kCFNotFound, 0)    (7, 0)
; user info           (kCFNotFound, 0)    (7, 0)
; host                (7, 13)             (4, 16)
; port                (kCFNotFound, 0)    (20, 0)
; parameter           (kCFNotFound, 0)    (29, 0)
; query               (kCFNotFound, 0)    (29, 0)
; fragment            (kCFNotFound, 0)    (29, 0)
; 
; 
; For the URL ./relPath/file.html#fragment
; 
; Component           returned range      rangeIncludingSeparators
; scheme              (kCFNotFound, 0)    (0, 0)
; net location        (kCFNotFound, 0)    (0, 0)
; path                (0, 19)             (0, 20)
; resource specifier  (20, 8)             (19, 9)
; user                (kCFNotFound, 0)    (0, 0)
; password            (kCFNotFound, 0)    (0, 0)
; user info           (kCFNotFound, 0)    (0, 0)
; host                (kCFNotFound, 0)    (0, 0)
; port                (kCFNotFound, 0)    (0, 0)
; parameter           (kCFNotFound, 0)    (19, 0)
; query               (kCFNotFound, 0)    (19, 0)
; fragment            (20, 8)             (19, 9)
; 
; 
; For the URL scheme://user:pass@host:1/path/path2/file.html;params?query#fragment
; 
; Component           returned range      rangeIncludingSeparators
; scheme              (0, 6)              (0, 9)
; net location        (9, 16)             (6, 19)
; path                (25, 21)            (25, 22) 
; resource specifier  (47, 21)            (46, 22)
; user                (9, 4)              (6, 8)
; password            (14, 4)             (13, 6)
; user info           (9, 9)              (6, 13)
; host                (19, 4)             (18, 6)
; port                (24, 1)             (23, 2)
; parameter           (47, 6)             (46, 8)
; query               (54, 5)             (53, 7)
; fragment            (60, 8)             (59, 9)
; 

(deftrap-inline "_CFURLGetByteRangeForComponent" 
   ((returnArg (:pointer :CFRange))
    (url (:pointer :__CFURL))
    (component :SInt32)
    (rangeIncludingSeparators (:pointer :CFRange))
   )                                            ; AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
   nil
() )

; #endif

;  Returns a string with any percent escape sequences that do NOT 
;  correspond to characters in charactersToLeaveEscaped with their 
;  equivalent.  Returns NULL on failure (if an invalid percent sequence 
;  is encountered), or the original string (retained) if no characters 
;  need to be replaced. Pass NULL to request that no percent escapes be 
;  replaced, or the empty string (CFSTR("")) to request that all percent 
;  escapes be replaced.  Uses UTF8 to interpret percent escapes. 

(deftrap-inline "_CFURLCreateStringByReplacingPercentEscapes" 
   ((allocator (:pointer :__CFAllocator))
    (originalString (:pointer :__CFString))
    (charactersToLeaveEscaped (:pointer :__CFString))
   )
   (:pointer :__CFString)
() )

; #if MAC_OS_X_VERSION_10_3 <= MAC_OS_X_VERSION_MAX_ALLOWED
;  As above, but allows you to specify the encoding to use when interpreting percent escapes 

(deftrap-inline "_CFURLCreateStringByReplacingPercentEscapesUsingEncoding" 
   ((allocator (:pointer :__CFAllocator))
    (origString (:pointer :__CFString))
    (charsToLeaveEscaped (:pointer :__CFString))
    (encoding :UInt32)
   )                                            ; AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER
   (:pointer :__CFString)
() )

; #endif

;  Creates a copy or originalString, replacing certain characters with 
;  the equivalent percent escape sequence based on the encoding specified. 
;  If the originalString does not need to be modified (no percent escape 
;  sequences are missing), may retain and return originalString. 
;  If you are uncertain of the correct encoding, you should use UTF-8, 
;  which is the encoding designated by RFC 2396 as the correct encoding 
;  for use in URLs.  The characters so escaped are all characters that 
;  are not legal URL characters (based on RFC 2396), plus any characters 
;  in legalURLCharactersToBeEscaped, less any characters in 
;  charactersToLeaveUnescaped.  To simply correct any non-URL characters 
;  in an otherwise correct URL string, do: 
;  newString = CFURLCreateStringByAddingPercentEscapes(NULL, origString, NULL, NULL, kCFStringEncodingUTF8); 

(deftrap-inline "_CFURLCreateStringByAddingPercentEscapes" 
   ((allocator (:pointer :__CFAllocator))
    (originalString (:pointer :__CFString))
    (charactersToLeaveUnescaped (:pointer :__CFString))
    (legalURLCharactersToBeEscaped (:pointer :__CFString))
    (encoding :UInt32)
   )
   (:pointer :__CFString)
() )

; #if !defined(DARWIN)

(deftrap-inline "_CFURLCreateFromFSRef" 
   ((allocator (:pointer :__CFAllocator))
    (fsRef (:pointer :fsref))
   )
   (:pointer :__CFURL)
() )

(deftrap-inline "_CFURLGetFSRef" 
   ((url (:pointer :__CFURL))
    (fsRef (:pointer :struct))
   )
   :Boolean
() )

; #endif /* !DARWIN */


; #if defined(__cplusplus)
#|
}
#endif
|#

; #endif /* !__COREFOUNDATION_CFURL__ */


(provide-interface "CFURL")